<?php

/**
 * Classe : Utilisateur
 * @author Remi
 * @version 1.0
 */
class Utilisateur
{

    /**
     * @var int
     */
    protected $Id;
    /**
     * @var string
     */
    protected $TypeUtilisateur;   // Administrateur, Responsable de stage
    /**
     * @var int
     */
    protected $StatutUtilisateur; // Etudiant, Enseignant, ContactEntreprise
    /**
     * @var string
     */
    protected $Nom;
    /**
     * @var string
     */
    protected $Prenom;
    /**
     * @var string
     */
    protected $Email;
    /**
     * @var string
     */
    protected $Password;
    /**
     * @var int
     */
    protected $DateCreation;
    /**
     * @var int
     */
    protected $DateDerniereConn;
    //Gestion erreur requete
    /**
     * @var bool
     */
    public $requeteOk;
    /**
     * @var string
     */
    public $errormsg;

    /**
     *
     * @param int $idM
     */
    public function __construct($idM = 0)
    {
        //Traitement
        if (empty($idM))
        {
            //On retourne un objet initialis&eacute;
            $this->Id = 0;

            //String
            $this->Nom = "";
            $this->Prenom = "";

            $this->Email = "";
            $this->Password = "";

            //Date
            $this->DateCreation = "";
            $this->DateDerniereConn = "";
        }
        else
        {
            $sql = SQL::getInstance()->getConnection();
            //On retourne l'entr&eacute;e demand&eacute;e
            $query = 'SELECT a.*, GROUP_CONCAT(CAST(b.IdTypeUtilisateur AS CHAR)) as types
					  FROM Utilisateur a
					  LEFT JOIN UtilisateurTypeRS b ON b.IdUtilisateur = a .IdUtilisateur
					  WHERE a.IdUtilisateur = :id
					  GROUP BY IdUtilisateur';
            $c = $sql->prepare($query);
            $c->bindParam(':id', $idM, PDO::PARAM_INT);
            //Ex&eacute;cution de la requ&ecirc;te retourne false si echec
            if ($c->execute())
            {
                $result = $c->fetch(PDO::FETCH_OBJ);
                if (!empty($result))
                {
                    $this->Id = $result->IdUtilisateur;

                    $this->TypeUtilisateur = $result->types;

                    $this->StatutUtilisateur = $result->StatutUtilisateur;

                    //String
                    $this->Nom = $result->NomUtilisateur;
                    $this->Prenom = $result->PrenomUtilisateur;
                    $this->Email = $result->EmailUtilisateur;
                    $this->Password = $result->PasswordUtilisateur;

                    //Date
                    $this->DateCreation = $result->DateCreationUtilisateur;
                    $this->DateDerniereConn = $result->DateDerniereVisite;

                    $this->requeteOk = true;
                    $this->errormsg = "Utilisateur trouve";
                }
                else
                {

                    $this->requeteOk = false;
                    $this->errormsg = "Ce Utilisateur n'existe pas !";
                }
            }
            else
            {
                //R&eacute;cup&eacute;ration de l'erreur dans la variable de classe
                /*
                  Pour chaque new avec passage de param&egrave;tres vous pouvez savoir si vous avez bien un r&eacute;sultat, si false n'oubliez pas de g&eacute;r&eacute;z l'affichage du message,...
                 */
                $this->requeteOk = false;
                $this->errormsg = $c->errorInfo();
            }
        }
    }

    /**
     * Ajout Bdd
     * @todo Ajouter la creation du repo pour l'upload des documents persos
     */
    public function insertUtilisateur()
    {
        $sql = SQL::getInstance()->getConnection();
        $query =
                'INSERT INTO Utilisateur
		(
			 NomUtilisateur,
			 PrenomUtilisateur,
			 DateCreationUtilisateur,
			 DateDerniereVisite,
			 PasswordUtilisateur,
			 EmailUtilisateur,
			 StatutUtilisateur
		)
		VALUES
		(
 			:nomM, 	
			:prenomM,
			:dateCrea,
			:dateConn,
			:password,
			:email,
			:statut
		)';

        $query2 = "INSERT INTO UtilisateurTypeRS(IdUtilisateur,IdTypeUtilisateur) VALUES(:id,:type)";
        $sql->beginTransaction();
        try
        {
            $c = $sql->prepare($query);

            $c->bindParam(':nomM', $this->Nom, PDO::PARAM_STR);
            $c->bindParam(':prenomM', $this->Prenom, PDO::PARAM_STR);
            $c->bindParam(':password', $this->Password, PDO::PARAM_STR);
            $c->bindParam(':email', $this->Email, PDO::PARAM_STR);

            $c->bindParam(':dateCrea', $this->DateCreation, PDO::PARAM_STR);
            $c->bindParam(':dateConn', $this->DateDerniereConn, PDO::PARAM_STR);
            $c->bindParam(':statut', $this->StatutUtilisateur, PDO::PARAM_STR);

            if ($c->execute())
            {
                $this->Id = $sql->lastInsertId();

                $types = explode(',', $this->TypeUtilisateur);
                $bool = true;
                if (!empty($types))
                {
                    foreach ($types as $type)
                    {
                        if ($bool === false)
                        {
                            break;
                        }

                        if (!empty($type))
                        {
                            $c2 = $sql->prepare($query2);
                            $c2->bindParam(':id', $this->Id, PDO::PARAM_INT);
                            $c2->bindParam(':type', $type, PDO::PARAM_INT);

                            if ($c2->execute())
                            {
                                $bool = true;
                            }
                            else
                            {
                                $bool = false;
                            }
                        }
                    }
                }

                if ($bool === true)
                {
                    $sql->commit();
                    $c->closeCursor();
                    $this->requeteOk = true;
                    $this->errormsg = "";
                }
                else
                {
                    $this->requeteOk = false;
                    $this->errormsg = $c->errorInfo();
                    $sql->rollback();
                    $c->closeCursor();
                    $this->Id = 0;
                }


                //Creation de son repo pour documents
                //obtention du repertoire
                //$myDir = $_SERVER['DOCUMENT_ROOT'].'/upload/Utilisateur/';
                //$myDir = $myDir.$this->IdUtilisateur;
                //$boolDir = mkdir ($myDir);
            }
            else
            {
                $this->requeteOk = false;
                $this->errormsg = $c->errorInfo();
                $sql->rollback();
                $c->closeCursor();
                $this->Id = 0;
            }
        }
        catch (PDOException $Exception)
        {
            $this->requeteOk = false;
            $this->errormsg = $c->errorInfo();
            $sql->rollback();
            $c->closeCursor();
            $this->Id = 0;
        }
        return $this->Id;
    }

    /**
     * Update Bdd
     */
    public function updateUtilisateur()
    {
        $sql = SQL::getInstance()->getConnection();
        $query =
                'UPDATE Utilisateur
		SET 
			 NomUtilisateur = :nomM,
			 PrenomUtilisateur = :prenomM,
			 DateCreationUtilisateur = :dateCrea,
			 DateDerniereVisite = :dateConn,
			 PasswordUtilisateur = :password,
			 EmailUtilisateur = :email,
			 StatutUtilisateur = :statut
		WHERE IdUtilisateur = :id';

        $query2 = "INSERT INTO UtilisateurTypeRS(IdUtilisateur,IdTypeUtilisateur) VALUES(:id,:type)";

        $sql->beginTransaction();
        try
        {
            $c = $sql->prepare($query);
            $c->bindParam(':id', $this->Id, PDO::PARAM_INT);

            $c->bindParam(':nomM', $this->Nom, PDO::PARAM_STR);
            $c->bindParam(':prenomM', $this->Prenom, PDO::PARAM_STR);
            $c->bindParam(':password', $this->Password, PDO::PARAM_STR);
            $c->bindParam(':email', $this->Email, PDO::PARAM_STR);

            $c->bindParam(':dateCrea', $this->DateCreation, PDO::PARAM_STR);
            $c->bindParam(':dateConn', $this->DateDerniereConn, PDO::PARAM_STR);
            $c->bindParam(':statut', $this->StatutUtilisateur, PDO::PARAM_STR);

            if ($c->execute())
            {
                $c3 = $sql->prepare("DELETE FROM UtilisateurTypeRS WHERE IdUtilisateur = :id");

                $c3->bindParam(':id', $this->Id, PDO::PARAM_INT);
                if ($c3->execute())
                {
                    $types = explode(',', $this->TypeUtilisateur);
                    $bool = true;
                    if (!empty($types))
                    {
                        foreach ($types as $type)
                        {
                            if ($bool === false)
                            {
                                break;
                            }

                            if (!empty($type))
                            {
                                $c2 = $sql->prepare($query2);
                                $c2->bindParam(':id', $this->Id, PDO::PARAM_INT);
                                $c2->bindParam(':type', $type, PDO::PARAM_INT);

                                if ($c2->execute())
                                {
                                    $bool = true;
                                }
                                else
                                {
                                    $bool = false;
                                }
                            }
                        }
                    }

                    if ($bool === true)
                    {
                        $sql->commit();
                        $c->closeCursor();
                        $this->requeteOk = true;
                        $this->errormsg = "";
                    }
                    else
                    {
                        $this->requeteOk = false;
                        $this->errormsg = $c->errorInfo();
                        $sql->rollback();
                        $c->closeCursor();
                    }
                }
                else
                {
                    $this->requeteOk = false;
                    $this->errormsg = $c->errorInfo();
                    $sql->rollback();
                    $c->closeCursor();
                }
            }
            else
            {
                $this->requeteOk = false;
                $this->errormsg = $c->errorInfo();
                $sql->rollback();
                $c->closeCursor();
            }
        }
        catch (PDOException $Exception)
        {
            $this->requeteOk = false;
            $this->errormsg = $c->errorInfo();
            $sql->rollback();
            $c->closeCursor();
        }
    }

    /**
     *
     * @return int
     */
    public function getIdUtilisateur()
    {
        return $this->Id;
    }

    /**
     *
     * @param string $nomM
     * @return array
     */
    public function setNomUtilisateur($nomM)
    {
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        $errTab = array("boolOk" => true, "errmsg" => "");

        if (isset($nomM) && $nomM != "" && strlen($nomM) < 100)
        {
            $this->Nom = htmlentities($nomM);
        }
        else
        {
            if (!isset($nomM))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le nom ne peut &ecirc;tre vide !";
            }
            if (isset($nomM) && $nomM == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le nom ne peut &ecirc;tre vide !";
            }
            else
            {
                if (isset($nomM) && strlen($nomM) > 100)
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Le nom doit &ecirc;tre compris entre 1 et 100 caract&egrave;res !";
                }
                else
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Ce nom n'est pas valide !";
                }
            }
            $this->Nom = "";
        }
        return $errTab;
    }

    /**
     *
     * @return string
     */
    public function getNomUtilisateur()
    {
        return stripslashes($this->Nom);
    }

    /**
     *
     * @param string $nomM
     * @return array
     */
    public function setPrenomUtilisateur($nomM)
    {
        $errTab = array("boolOk" => true, "errmsg" => "");
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        if (isset($nomM) && $nomM != "" && strlen($nomM) < 100)
        {
            $this->Prenom = htmlentities($nomM);
            $this->errormsg = "";
        }
        else
        {
            if (!isset($nomM))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le pr&eacute;nom ne peut &ecirc;tre vide !";
            }
            if (isset($nomM) && $nomM == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le pr&eacute;nom ne peut &ecirc;tre vide !";
            }
            else
            {
                if (isset($nomM) && strlen($nomM) > 100)
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Le pr&eacute;nom doit &ecirc;tre compris entre 1 et 100 caract&egrave;res !";
                }
                else
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Ce pr&eacute;nom n'est pas valide !";
                }
            }
            $this->Prenom = "";
        }
        return $errTab;
    }

    /**
     *
     * @return string
     */
    public function getPrenomUtilisateur()
    {
        return stripslashes($this->Prenom);
    }

    /**
     *
     * @param string $nomM
     * @return array
     */
    public function setEmailUtilisateur($nomM)
    {
        $errTab = array("boolOk" => true, "errmsg" => "");
        $regmail = "^[a-zA-Z0-9_\-]+(\.[a-zA-Z0-9_\-]+)*@[a-zA-Z0-9\-]+(\.[a-zA-Z0-9\-]+)*\.(([a-zA-Z]{2,3})|(aero|coop|info|museum|name|gouv))$^";
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        if (isset($nomM) && $nomM != "" && strlen($nomM) < 255 && preg_match($regmail, $nomM))
        {
            $this->Email = $nomM;
            $this->errormsg = "";
        }
        else
        {
            if (!isset($nomM))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Votre email ne peut &ecirc;tre vide !";
            }
            if (isset($nomM) && $nomM == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Votre email ne peut &ecirc;tre vide !";
            }
            else
            {
                if (isset($nomM) && strlen($nomM) > 255)
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Votre email doit &ecirc;tre compris entre 1 et 255 caract&egrave;res !";
                }
                else
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Votre email n'est pas valide !";
                }
            }
            $this->Email = "";
        }
        return $errTab;
    }

    /**
     *
     * @return string
     */
    public function getEmailUtilisateur()
    {
        return $this->Email;
    }

    /**
     *
     * @param string $nomM
     * @return array
     */
    public function setPassword($nomM)
    {
        $errTab = array("boolOk" => true, "errmsg" => "");
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        if (isset($nomM) && $nomM != "" && strlen($nomM) < 16 && strlen($nomM) > 5)
        {
            $this->Password = md5($nomM);
            $this->errormsg = "";
        }
        else
        {
            if (!isset($nomM))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Votre mot de passe ne peut &ecirc;tre vide !";
            }
            if (isset($nomM) && $nomM == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Votre mot de passe ne peut &ecirc;tre vide !";
            }
            else
            {
                if (isset($nomM) && (strlen($nomM) > 16 || strlen($nomM) < 5))
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Votre mot de passe doit &ecirc;tre compris entre 6 et 15 caract&egrave;res !";
                }
                else
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Votre mot de passe n'est pas valide !";
                }
            }
            $this->Password = "";
        }

        return $errTab;
    }

    /**
     *
     * @return string
     */
    public function getPass()
    {
        return $this->Password;
    }

    public function setDateCreation()
    {
        $this->DateCreation = time();
    }

    /**
     *
     * @return int
     */
    public function getDateCreation()
    {
        return $this->DateCreation;
    }

    public function setDateDerniereConn()
    {
        $this->DateDerniereConn = time();
    }

    /**
     *
     * @return int
     */
    public function getDateDerniereConn()
    {
        return $this->DateDerniereConn;
    }

    /**
     *
     * @return string Comma-Separated string
     */
    public function getIdTypeUser()
    {
        return $this->TypeUtilisateur;
    }

    /**
     *
     * @param string $value ex: 2,3,4,5
     * @return array
     */
    public function setIdTypeUser($value)
    {
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        $errTab = array("boolOk" => true, "errmsg" => "");

        if (isset($value) && $value != "" && strlen($value) <= 255)
        {
            $this->TypeUtilisateur = $value;
        }
        else
        {
            if (!isset($value))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le type ne peut etre null !";
            }
            if (isset($value) && $value == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le type ne peut etre vide !";
            }
            else
            {
                if (isset($value) && strlen($value) > 255)
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Le type doit etre compris entre 1 et 255 caracteres  ex (1,2,3)!";
                }
                else
                {
                    $errTab["boolOk"] = false;
                    $errTab["errmsg"] = "Ce type n'est pas valide !";
                }
            }

            $this->TypeUtilisateur = "";
        }
        return $errTab;
    }

    /**
     *
     * @param string $value
     * @return array
     */
    public function setIdStatutUtilisateur($value)
    {
        //Verif Type + verif Nulle, si bon mis a jour, sinon message erreur
        $errTab = array("boolOk" => true, "errmsg" => "");

        if (isset($value))
        {
            $this->StatutUtilisateur = $value;
        }
        else
        {
            if (!isset($value))
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le StatutUtilisateur ne peut etre null !";
            }
            if (isset($value) && $value == "")
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Le StatutUtilisateur ne peut etre vide !";
            }
            else
            {
                $errTab["boolOk"] = false;
                $errTab["errmsg"] = "Ce StatutUtilisateur n'est pas valide !";
            }

            $this->StatutUtilisateur = "";
        }
        return $errTab;
    }

    /**
     * @static
     * @param string $loginn
     * @return bool if login exist return true
     */
    static public function checkIfExistLogin($loginn)
    {
        $sql = SQL::getInstance()->getConnection();
        $query = 'SELECT Utilisateur.* FROM Utilisateur WHERE Utilisateur.EmailUtilisateur = :id';
        $c = $sql->prepare($query);
        $c->bindParam(':id', $loginn, PDO::PARAM_STR);
        $c->execute();
        $result = $c->fetch(PDO::FETCH_OBJ);
        if (empty($result))
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    /**
     * @static
     * @param string $loginn
     * @return Utilisateur
     */
    static public function getUserByLogin($loginn)
    {
        $sql = SQL::getInstance()->getConnection();
        $query = 'SELECT Utilisateur.* FROM Utilisateur WHERE Utilisateur.EmailUtilisateur = :id';
        $c = $sql->prepare($query);
        $c->bindParam(':id', $loginn, PDO::PARAM_STR);
        $c->execute();
        $result = $c->fetch(PDO::FETCH_OBJ);
        if (!empty($result))
            return $result;
        return null;
    }

    /**
     * @static
     * @param int $type
     * @param int $limit
     * @param int $begin
     * @return array Array d'utilisateur
     */
    static public function getList($type=-1, $limit=0, $begin=0)
    {
        if (empty($limit))
        {
            $sql = SQL::getInstance()->getConnection();
            $query = 'SELECT Utilisateur.* FROM Utilisateur';
            $c = $sql->query($query);
            $result = $c->fetchAll(PDO::FETCH_OBJ);
            return $result;
        }
        else
        {
            $sql = SQL::getInstance()->getConnection();
            $query = 'SELECT Utilisateur.* FROM Utilisateur';
            if ($type != -1)
                $query .= " WHERE StatutUtilisateur = :type";
            $query .= ' LIMIT :begin,:limit';
            $c = $sql->prepare($query);
            $c->bindParam(':begin', $begin, PDO::PARAM_INT);
            $c->bindParam(':limit', $limit, PDO::PARAM_INT);
            if ($type != -1)
                $c->bindParam(':type', $type, PDO::PARAM_STR);
            if ($c->execute())
            {
                $result = $c->fetchAll(PDO::FETCH_OBJ);
                return $result;
            }
            else
            {
                return array();
            }
        }
    }

    /**
     * @static
     * @param int $id
     * @return string
     */
    static public function getStatutById($id=0)
    {
        if (!empty($id))
        {
            $sql = SQL::getInstance()->getConnection();
            $query = 'SELECT StatutUtilisateur FROM Utilisateur WHERE IdUtilisateur = :id';
            $c = $sql->prepare($query);
            $c->bindParam(':id', $id, PDO::PARAM_INT);
            $c->execute();
            $result = $c->fetch(PDO::FETCH_OBJ);
            switch ($result->StatutUtilisateur)
            {
                case '0':
                    return "Etudiant";
                    break;
                case '1':
                    return "Enseignant";
                    break;
                case '2':
                    return "Contact";
                    break;
                default:
                    return "";
            }
        }
        else
        {
            return "";
        }
    }

    /**
     * @static
     * @param int $ids
     * @return string
     */
    static public function getTypeById($ids="")
    {
        if (!empty($ids))
        {
            $sql = SQL::getInstance()->getConnection();
            $query = 'SELECT GROUP_CONCAT(b.NomTypeUtilisateur) as types
			FROM UtilisateurTypeRS a
			INNER JOIN  TypeUtilisateur b ON b.IdTypeUtilisateur = a.IdTypeUtilisateur
			WHERE IdUtilisateur = :id
			GROUP BY IdUtilisateur';
            $c = $sql->prepare($query);
            $c->bindParam(':id', $ids, PDO::PARAM_INT);
            $c->execute();
            $result = $c->fetch(PDO::FETCH_OBJ);
            if (empty($result->types))
            {
                return "Normal";
            }
            else
            {
                return $result->types;
            }
        }
        else
        {
            return "";
        }
    }

    /**
     * @static
     * @param int $type
     * @return int Nombre d'utilisateur du type demande
     */
    static public function globalCount($type=-1)
    {
       $sql = SQL::getInstance()->getConnection();
        if ($type == -1)
        {
            $query = 'SELECT COUNT(IdUtilisateur) as count FROM Utilisateur';
            $c = $sql->query($query);
            $result = $c->fetch(PDO::FETCH_OBJ);
        }
        else
        {
            $query = 'SELECT COUNT(IdUtilisateur) as count FROM Utilisateur  WHERE StatutUtilisateur = :type';
            $c = $sql->prepare($query);
            $c->bindParam(':type', $type, PDO::PARAM_STR);
            $c->execute();
            $result = $c->fetch(PDO::FETCH_OBJ);
            //var_dump($result);
        }
        return $result->count;
    }

    /**
     * @static
     * @param int $id
     * @return Utilisateur
     */
    static public function getGoodInstanceOfUser($id=0)
    {
        if (!empty($id))
        {
            $sql = SQL::getInstance()->getConnection();
            $query = 'SELECT StatutUtilisateur FROM Utilisateur WHERE IdUtilisateur = :id';
            $c = $sql->prepare($query);
            $c->bindParam(':id', $id, PDO::PARAM_INT);
            $c->execute();
            $result = $c->fetch(PDO::FETCH_OBJ);
            switch ($result->StatutUtilisateur)
            {
                case '0':
                    return new Etudiant($id);
                    break;
                case '1':
                    return new Enseignant($id);
                    break;
                case '2':
                    return new ContactEntreprise($id);
                    break;
                default:
                    return new Utilisateur();
            }
        }
        else
        {
            return new Utilisateur();
        }
    }

    /**
     * @static
     * @param int $id
     * @return Utilisateur composed by Nom and Prenom
     */
    static public function getIdentityByID($id=0)
    {
        if (!empty($id))
        {
            $sql = SQL::getInstance()->getConnection();
            $query = "SELECT NomUtilisateur, PrenomUtilisateur FROM Utilisateur WHERE IdUtilisateur = :id";
            $c = $sql->prepare($query);
            $c->bindParam(":id", $id, PDO::PARAM_INT);
            if ($c->execute())
            {
                $result = $c->fetch(PDO::FETCH_OBJ);
                return $result;
            }
            else
            {
                return "";
            }
        }
        else
        {
            return "";
        }
    }

}

?>